// 泛型 : 对一个类或者一个方法做一个整体类型约束
// 写法 : 在类的名字后面写 或者方法的名字后面写
class HandleObj<T extends keyof Person>{
  // 只能在类里面调用
  private obj
  constructor(obj:Person){
    this.obj = obj
  }
  // setName: () => void;
  // keyof : 类型索引 只能是person其中的一个值
  public get<T>(key : T):string{
    return this.obj[key]
  }
  public set(key : T, value:string):void{
    this.obj[key] = value
  }
  public getObject():Person{
    return this.obj
  }
  protected delete(key : T):boolean{
    return delete obj[key]
  }
}
// 接口可以被实现的
// 可以封装一个底层方法 但是不具体实现 具体实现 类的里面实现方法
// implements
// interface A{
//   setName:()=>void
// }

type Person ={
  username:string;
  password:string;
}

// & | 


const obj :Person = {
  username:'abc',
  password:'123456'
}

new HandleObj(obj).get('password')
new HandleObj(obj).set('password','123')

let obj1 = [
  {
    value:0,
    left:{
      value:20,
      right:{
        value:30,
        left:{
          value:10
        },
        right:{
          value:20
        }
      }
    },
    right:{
      value:30,
      left:{
        value:10
      }
    }
  }
]

type Tree<T> = {
  value:T,
  left? : Tree<T>,
  right?: Tree<T>
}

function getTree(obj:Array<Tree<number>>){

}

getTree(obj1)